#pragma once
#include "mysql.hpp"
#include "chat_session.hxx"
#include "chat_session-odb.hxx"
#include "mysql_chat_session_member.hpp"

namespace mag {  
    // ChatSessionTable 类管理聊天会话的数据库操作
    class ChatSessionTable {
        public:
            // 使用智能指针来引用 ChatSessionTable 对象
            using ptr = std::shared_ptr<ChatSessionTable>;

            // 构造函数，接受数据库连接对象 db
            ChatSessionTable(const std::shared_ptr<odb::core::database> &db) : _db(db) {}

            // 插入会话信息到数据库
            bool insert(ChatSession &cs) {
                try {
                    odb::transaction trans(_db->begin());  // 开启数据库事务
                    _db->persist(cs);  // 保存会话数据
                    trans.commit();  // 提交事务
                } catch (std::exception &e) {
                    LOG_ERROR("新增会话失败 {}:{}！", cs.chat_session_name(), e.what());  // 出现异常时记录日志
                    return false;
                }
                return true;
            }

            // 根据会话ID删除会话及成员信息
            bool remove(const std::string &ssid) {
                try {
                    odb::transaction trans(_db->begin());  // 开启数据库事务
                    typedef odb::query<ChatSession> query;
                    typedef odb::result<ChatSession> result;
                    _db->erase_query<ChatSession>(query::chat_session_id == ssid);  // 删除会话

                    typedef odb::query<ChatSessionMember> mquery;
                    _db->erase_query<ChatSessionMember>(mquery::session_id == ssid);  // 删除会话成员
                    trans.commit();  // 提交事务
                } catch (std::exception &e) {
                    LOG_ERROR("删除会话失败 {}:{}！", ssid, e.what());  // 出现异常时记录日志
                    return false;
                }
                return true;
            }

            // 根据用户ID和对方ID删除单聊会话
            bool remove(const std::string &uid, const std::string &pid) {
                try {
                    odb::transaction trans(_db->begin());  // 开启数据库事务
                    typedef odb::query<SingleChatSession> query;
                    typedef odb::result<SingleChatSession> result;

                    // 查询单聊会话，匹配两个用户（uid 和 pid）
                    auto res = _db->query_one<SingleChatSession>(
                        query::csm1::user_id == uid && 
                        query::csm2::user_id == pid && 
                        query::css::chat_session_type == ChatSessionType::SINGLE);

                    std::string cssid = res->chat_session_id;  // 获取会话ID
                    typedef odb::query<ChatSession> cquery;
                    _db->erase_query<ChatSession>(cquery::chat_session_id == cssid);  // 删除会话

                    typedef odb::query<ChatSessionMember> mquery;
                    _db->erase_query<ChatSessionMember>(mquery::session_id == cssid);  // 删除会话成员
                    trans.commit();  // 提交事务
                } catch (std::exception &e) {
                    LOG_ERROR("删除会话失败 {}-{}:{}！", uid, pid, e.what());  // 出现异常时记录日志
                    return false;
                }
                return true;
            }

            // 根据会话ID查询会话信息
            std::shared_ptr<ChatSession> select(const std::string &ssid) {
                std::shared_ptr<ChatSession> res;
                try {
                    odb::transaction trans(_db->begin());  // 开启数据库事务
                    typedef odb::query<ChatSession> query;
                    typedef odb::result<ChatSession> result;
                    res.reset(_db->query_one<ChatSession>(query::chat_session_id == ssid));  // 查询会话
                    trans.commit();  // 提交事务
                } catch (std::exception &e) {
                    LOG_ERROR("通过会话ID获取会话信息失败 {}:{}！", ssid, e.what());  // 出现异常时记录日志
                }
                return res;
            }

            // 获取当前用户的所有单聊会话
            std::vector<SingleChatSession> singleChatSession(const std::string &uid) {
                std::vector<SingleChatSession> res;
                try {
                    odb::transaction trans(_db->begin());  // 开启数据库事务
                    typedef odb::query<SingleChatSession> query;
                    typedef odb::result<SingleChatSession> result;

                    // 查询用户的所有单聊会话（排除自己）
                    result r(_db->query<SingleChatSession>(
                        query::css::chat_session_type == ChatSessionType::SINGLE && 
                        query::csm1::user_id == uid && 
                        query::csm2::user_id != query::csm1::user_id));
                    for (result::iterator i(r.begin()); i != r.end(); ++i) {
                        res.push_back(*i);  // 将查询结果加入返回列表
                    }
                    trans.commit();  // 提交事务
                } catch (std::exception &e) {
                    LOG_ERROR("获取用户 {} 的单聊会话失败:{}！", uid, e.what());  // 出现异常时记录日志
                }
                return res;
            }

            // 获取当前用户的所有群聊会话
            std::vector<GroupChatSession> groupChatSession(const std::string &uid) {
                std::vector<GroupChatSession> res;
                try {
                    odb::transaction trans(_db->begin());  // 开启数据库事务
                    typedef odb::query<GroupChatSession> query;
                    typedef odb::result<GroupChatSession> result;

                    // 查询用户的所有群聊会话
                    result r(_db->query<GroupChatSession>(
                        query::css::chat_session_type == ChatSessionType::GROUP && 
                        query::csm::user_id == uid ));
                    for (result::iterator i(r.begin()); i != r.end(); ++i) {
                        res.push_back(*i);  // 将查询结果加入返回列表
                    }
                    trans.commit();  // 提交事务
                } catch (std::exception &e) {
                    LOG_ERROR("获取用户 {} 的群聊会话失败:{}！", uid, e.what());  // 出现异常时记录日志
                }
                return res;
            }

        private:
            std::shared_ptr<odb::core::database> _db;  // 数据库连接对象
    };
}
